home *** CD-ROM | disk | FTP | other *** search
/ Aminet 49 / Aminet 49 (2002)(GTI - Schatztruhe)[!][Jun 2002].iso / Aminet / util / misc / MetaToolPrefs.lha / MetaToolPrefs / MetaToolPrefs.cpp < prev    next >
C/C++ Source or Header  |  2002-03-16  |  63KB  |  1,729 lines
  1. /* MetaToolPrefs (C) by Martin Steigerwald */
  2. /* Released under GPL license, version 2 and up,
  3.    from version 3.3 and above 
  4. */
  5.  
  6. /* includes */
  7. #include <clib/alib_protos.h>
  8. #include <clib/exec_protos.h>
  9. #include <clib/dos_protos.h>
  10. #include <clib/intuition_protos.h>
  11. #include <clib/locale_protos.h>
  12. #include <clib/utility_protos.h>
  13. #include <clib/dospath_protos.h>
  14. #include <clib/muimaster_protos.h>
  15.  
  16. #include <pragmas/exec_pragmas.h>
  17. #include <pragmas/dos_pragmas.h>
  18.  
  19. // #include <pragmas/dospath_pragmas.h>
  20. // DOSPath Pragmas im StormC-Format
  21.  
  22. #pragma amicall(DOSPathBase, 0x24,FreePathList(a0))
  23. #pragma amicall(DOSPathBase, 0x36,FindFileInPathList(a0,a1))
  24. #pragma amicall(DOSPathBase, 0x42,GetProcessPathList(a0))
  25. #pragma amicall(DOSPathBase, 0x4e,CopyWorkbenchPathList(a0,a1))
  26.  
  27. #include <pragmas/intuition_pragmas.h>
  28. #include <pragmas/locale_pragmas.h>
  29. #include <pragmas/utility_pragmas.h>
  30. #include <pragmas/muimaster_pragmas.h>
  31.  
  32. #include <libraries/asl.h>
  33. #include <libraries/dospath.h>
  34. #include <libraries/gadtools.h>
  35. #include <libraries/locale.h>
  36. #include <libraries/mui.h>
  37. #include <dos/dos.h>
  38. #include <dos/dosasl.h>
  39. #include <dos/rdargs.h>
  40. #include <libraries/gadtools.h>
  41. #include <exec/memory.h>
  42. #include <string.h>
  43.  
  44. #define CATCOMP_NUMBERS
  45. #define CATCOMP_ARRAY
  46. #include "MetaToolPrefs_strings.h"
  47.  
  48. /* defines */
  49.  
  50. #ifndef MAKE_ID
  51. #define MAKE_ID(a,b,c,d) ((ULONG) (a)<<24 | (ULONG) (b)<<16 | (ULONG) (c)<<8 | (ULONG) (d))
  52. #endif
  53.  
  54. #define APP_NAME        "MetaToolPrefs"
  55. #define APP_AUTHOR      "Martin Steigerwald"
  56. #define APP_COPYRIGHT   "© 1996-2002 by Martin Steigerwald"
  57. #define APP_VERSION     "$VER: MetaToolPrefs 3.3 (16.3.2002)"
  58. #define APP_BASE        "METATOOLPREFS"
  59. #define ABOUTTEXT       "\33bMetaToolPrefs\33n\n\nVersion: %s\n%s"
  60.  
  61. #define MTPREFS_CATALOGVERSION 32
  62.  
  63. #define MAXMETATYPELENGTH       12
  64. #define MAXTOOLLENGTH           80
  65. #define MAXARGUMENTSLENGTH      80
  66. #define MAXFILENAMELENGTH       108
  67. #define MAXPATHNAMELENGTH       512
  68.  
  69. #define MODE_CHANGE_METATYPE    1    /* for updategadgets */
  70. #define MODE_CHANGE_TOOL        2
  71. #define MODE_CHANGE_ARGUMENTS   3
  72. #define MODE_CHANGE_WB          4
  73.  
  74. #define LINEBUFFERSIZE          256  /* for config file loading routine */
  75.  
  76. /* ixemul */
  77.  
  78. int __nocommandline=1;
  79.  
  80. static const char *MetaTypeNames[] =
  81. {
  82.     "8SVX",     "ANIM",     "BIN",      "DVI",      "GIF",
  83.     "GUIDE",    "HTML",     "ICONX",    "ILBM",     "INST",
  84.     "JPEG",     "MOVIE",    "PS",       "REXX",     "SOURCE",
  85.     "TEX",      "TEXT",     NULL
  86. };
  87.  
  88.  
  89. /* menudata */
  90.  
  91. enum { MEN_PROJECT_NEW=1, MEN_PROJECT_RELOAD, MEN_PROJECT_LOAD,
  92.     MEN_PROJECT_SAVE, MEN_PROJECT_SAVEAS, MEN_PROJECT_QUIT,
  93.     MEN_SETTINGS_CONFIGNAME, MEN_SETTINGS_MUI, MEN_ABOUT_APP, MEN_ABOUT_MUI };
  94.  
  95. static struct NewMenu MainMenu[] =
  96. {
  97.     { NM_TITLE, (STRPTR)MSG_MAINWINDOW_PROJECT_MENU    , 0  , 0, 0, 0 },
  98.     { NM_ITEM,  (STRPTR)MSG_MAINWINDOW_PROJECT_NEW     , "L", 0, 0, (APTR)MEN_PROJECT_NEW },
  99.     { NM_ITEM,  (STRPTR)MSG_MAINWINDOW_PROJECT_RELOAD  , "L", 0, 0, (APTR)MEN_PROJECT_RELOAD },
  100.     { NM_ITEM,  (STRPTR)MSG_MAINWINDOW_PROJECT_SAVE    , "S", 0, 0, (APTR)MEN_PROJECT_SAVE },
  101.     { NM_ITEM,  (STRPTR)MSG_MAINWINDOW_PROJECT_SAVEAS  , 0  , 0, 0, (APTR)MEN_PROJECT_SAVEAS },
  102.     { NM_ITEM,  (STRPTR)NM_BARLABEL                    , 0  , 0, 0, (APTR)0 },
  103.     { NM_ITEM,  (STRPTR)MSG_MAINWINDOW_PROJECT_QUIT    , "Q", 0, 0, (APTR)MEN_PROJECT_QUIT },
  104.     { NM_TITLE, (STRPTR)MSG_MAINWINDOW_SETTINGS_MENU   , 0  , 0, 0, 0 },
  105.     { NM_ITEM,  (STRPTR)MSG_MAINWINDOW_SETTINGS_CONFIGFILE
  106.                                                        , 0  , 0, 0, (APTR)MEN_SETTINGS_CONFIGNAME },
  107.     { NM_ITEM,  (STRPTR)MSG_MAINWINDOW_SETTINGS_MUI    , 0  , 0, 0, (APTR)MEN_SETTINGS_MUI },
  108.     { NM_TITLE, (STRPTR)MSG_MAINWINDOW_ABOUT_MENU      , 0  , 0, 0, 0 },
  109.     { NM_ITEM,  (STRPTR)MSG_MAINWINDOW_ABOUT_APP       , "?", 0, 0, (APTR)MEN_ABOUT_APP },
  110.     { NM_ITEM,  (STRPTR)MSG_MAINWINDOW_ABOUT_MUI       , 0  , 0, 0, (APTR)MEN_ABOUT_MUI },
  111.     { NM_END,   NULL                , 0  , 0, 0, 0 },
  112. };
  113.  
  114. enum { MEN_MTENTRYPANEL_SELECT_ALL=1, MEN_MTENTRYPANEL_DESELECT_ALL,
  115.     MEN_MTENTRYPANEL_TOGGLE_ALL, MEN_MTENTRYPANEL_CLOSE_ALL, MEN_MTENTRYPANEL_SETSAVE,
  116.     MEN_MTENTRYPANEL_UNSETSAVE, MEN_MTENTRYPANEL_CHECKCONFIG };
  117.  
  118. static struct NewMenu MTEntryPanelMenu[] =
  119. {
  120.     { NM_TITLE, (STRPTR)MSG_MTENTRYPANEL_MENU,          0 , 0, 0, 0 },
  121.     { NM_ITEM,  (STRPTR)MSG_MTENTRYPANEL_SELECT_ALL,    0 , 0, 0, (APTR)MEN_MTENTRYPANEL_SELECT_ALL },
  122.     { NM_ITEM,  (STRPTR)MSG_MTENTRYPANEL_DESELECT_ALL,  0 , 0, 0, (APTR)MEN_MTENTRYPANEL_DESELECT_ALL },
  123.     { NM_ITEM,  (STRPTR)MSG_MTENTRYPANEL_TOGGLE_ALL,    0 , 0, 0, (APTR)MEN_MTENTRYPANEL_TOGGLE_ALL },
  124.     { NM_ITEM,  (STRPTR)MSG_MTENTRYPANEL_CHECKCONFIG,   0 , 0, 0, (APTR)MEN_MTENTRYPANEL_CHECKCONFIG },
  125.     { NM_ITEM,  (STRPTR)MSG_MTENTRYPANEL_SETSAVE,       0 , 0, 0, (APTR)MEN_MTENTRYPANEL_SETSAVE },
  126.     { NM_ITEM,  (STRPTR)MSG_MTENTRYPANEL_UNSETSAVE,     0 , 0, 0, (APTR)MEN_MTENTRYPANEL_UNSETSAVE },
  127.     { NM_ITEM,  (STRPTR)MSG_MTENTRYPANEL_CLOSE_ALL,     0 , 0, 0, (APTR)MEN_MTENTRYPANEL_CLOSE_ALL },
  128.  
  129.     { NM_END,   NULL                , 0  , 0, 0, 0 },
  130. };
  131.  
  132. /* global data for MetaToolPrefs routines */
  133.  
  134. struct  Library *MUIMasterBase=NULL, *DOSPathBase=NULL;
  135. struct WBStartup *WBenchMsg;
  136.  
  137. struct Catalog *Catalog=NULL;
  138.  
  139. struct  MUI_CustomClass *DragCheckMark=NULL, *DragString_Class=NULL;
  140. struct  MUI_CustomClass *MTEntryList_Class=NULL, *MTEntryPanel_Class=NULL;
  141. struct  MUI_CustomClass *MTEditWindow_Class=NULL;
  142. struct  MUI_CustomClass *MainWindow_Class=NULL, *App_Class=NULL;
  143.  
  144. Object  *App;
  145.  
  146. ULONG   OSVersion;
  147.  
  148. /* MetaTypeEntry */
  149.  
  150. struct MetaTypeEntry
  151. {
  152.     char    MetaType[MAXMETATYPELENGTH];
  153.     char    Tool[MAXTOOLLENGTH];
  154.     char    Arguments[MAXARGUMENTSLENGTH];
  155.     BOOL    WB;
  156.     BOOL    FromCD;
  157.     Object  *EditWindow;
  158. };
  159.  
  160. #define DRAGTYPE_METATYPE   1
  161. #define DRAGTYPE_TOOL       2
  162. #define DRAGTYPE_ARGUMENTS  3
  163. #define DRAGTYPE_WB         4
  164.  
  165. #define MUISERIALNR_HELIOS  1007
  166. #define TAGBASE_HELIOS      (TAG_USER | (MUISERIALNR_HELIOS << 16))
  167.  
  168. #define MUIA_DragString_ObjectID          (TAGBASE_HELIOS | 0x1010)
  169.  
  170. #define MUIM_MTEntryList_Load       (TAGBASE_HELIOS | 0x1020)
  171. #define MUIM_MTEntryList_Save       (TAGBASE_HELIOS | 0x1021)
  172.  
  173. #define MUIA_MTEditWindow_Originator       (TAGBASE_HELIOS | 0x1030)
  174. #define MUIA_MTEditWindow_Entry            (TAGBASE_HELIOS | 0x1031)
  175. #define MUIA_MTEditWindow_CloseAble        (TAGBASE_HELIOS | 0x1032)
  176. #define MUIM_MTEditWindow_UpdateGadgets    (TAGBASE_HELIOS | 0x1033)
  177. #define MUIM_MTEditWindow_UpdateEntry      (TAGBASE_HELIOS | 0x1034)
  178.  
  179. #define MUIA_MTEntryPanel_CloseAble         (TAGBASE_HELIOS | 0x1040)
  180. #define MUIM_MTEntryPanel_Edit              (TAGBASE_HELIOS | 0x1041)
  181. #define MUIM_MTEntryPanel_New               (TAGBASE_HELIOS | 0x1042)
  182. #define MUIM_MTEntryPanel_Remove            (TAGBASE_HELIOS | 0x1043)
  183. #define MUIM_MTEntryPanel_QuitEdit          (TAGBASE_HELIOS | 0x1044)
  184. #define MUIM_MTEntryPanel_QuitEditAll       (TAGBASE_HELIOS | 0x1045)
  185. #define MUIM_MTEntryPanel_UpdateEntry       (TAGBASE_HELIOS | 0x1046)
  186. #define MUIM_MTEntryPanel_CheckConfig       (TAGBASE_HELIOS | 0x1047)
  187. #define MUIM_MTEntryPanel_SetSave           (TAGBASE_HELIOS | 0x1048)
  188.  
  189. #define MTEntryPanel_SetSave_Set        1
  190. #define MTEntryPanel_SetSave_UnSet      2
  191. #define MTEntryPanel_Edit_Active        1
  192. #define MTEntryPanel_Edit_Selected      2
  193.  
  194. #define MUIM_MainWindow_About               (TAGBASE_HELIOS | 0x1050)
  195. #define MUIM_MainWindow_Aboutmui            (TAGBASE_HELIOS | 0x1051)
  196. #define MUIM_MainWindow_Reload              (TAGBASE_HELIOS | 0x1052)
  197. #define MUIM_MainWindow_Save                (TAGBASE_HELIOS | 0x1053)
  198. #define MUIM_MainWindow_SaveAs              (TAGBASE_HELIOS | 0x1054)
  199. #define MUIM_MainWindow_ChangeConfigFile    (TAGBASE_HELIOS | 0x1055)
  200. #define MUIM_MainWindow_MUISettings         (TAGBASE_HELIOS | 0x1056)
  201. #define MUIM_MainWindow_Finish              (TAGBASE_HELIOS | 0x1057)
  202.  
  203. struct  MUIP_MTEntryList_Load       { ULONG MethodID; STRPTR file; ULONG FromCD; };
  204. struct  MUIP_MTEntryList_Save       { ULONG MethodID; STRPTR file; };
  205.  
  206. struct  MUIP_MTEditWindow_UpdateEntry   { ULONG MethodID; LONG mode; };
  207.  
  208. struct  MUIP_MTEntryPanel_Edit          { ULONG MethodID; ULONG TriggerValue; };
  209. struct  MUIP_MTEntryPanel_QuitEdit      { ULONG MethodID; struct MetaTypeEntry *entry; };
  210. struct  MUIP_MTEntryPanel_UpdateEntry   { ULONG MethodID; struct MetaTypeEntry *entry; };
  211. struct  MUIP_MTEntryPanel_SetSave       { ULONG MethodID; ULONG mode; };
  212.  
  213. struct  MUIP_MainWindow_Finish      { ULONG MethodID; ULONG quitmode; };
  214.  
  215.  
  216. /* start of code */
  217.  
  218. /* locale support funcs
  219.    taken from psi.c, thanks Stefan
  220. */
  221.  
  222. char *GetStr(int num)
  223. {
  224.         struct CatCompArrayType *cca = (struct CatCompArrayType *)CatCompArray;
  225.         while (cca->cca_ID != num) cca++;
  226.         if (LocaleBase) return(GetCatalogStr(Catalog,num,cca->cca_Str));
  227.         return((char *)cca->cca_Str);
  228. }
  229.  
  230. void LocalizeNewMenu(struct NewMenu *nm)
  231. {
  232.         for (;nm->nm_Type!=NM_END;nm++)
  233.                 if (nm->nm_Label != NM_BARLABEL)
  234.                         nm->nm_Label = GetStr((int)nm->nm_Label);
  235. }
  236.  
  237. /* support funcs
  238.    taken from psi.c, Thanks Stefan.
  239. */
  240.  
  241. ULONG DoSuperNew(struct IClass *cl, Object *obj, ULONG tag1,...)
  242. {
  243.     return(DoSuperMethod(cl, obj, OM_NEW, &tag1, NULL));
  244. }
  245.  
  246. LONG xget(Object *obj, ULONG attribute)
  247. {
  248.     LONG x=0; get(obj, attribute, &x); return(x);
  249. }
  250.  
  251. /* DragString Class */
  252.  
  253. struct DragString_Data
  254. {
  255.     ULONG   ObjectID;
  256. };
  257.  
  258. ULONG DragString_mDragQuery(struct IClass *cl, Object *obj,
  259.     struct MUIP_DragQuery *msg)
  260. {
  261.     struct DragString_Data *data = INST_DATA(cl, obj);
  262.  
  263.     if (msg->obj==obj)
  264.        return(MUIV_DragQuery_Refuse);
  265.     if (xget(msg->obj,MUIA_DragString_ObjectID)==data->ObjectID)
  266.        return(MUIV_DragQuery_Accept);
  267.     {
  268.         struct MetaTypeEntry *entry=NULL;
  269.         DoMethod(msg->obj, MUIM_List_GetEntry, MUIV_List_GetEntry_Active,
  270.             &entry);
  271.         if(entry) return(MUIV_DragQuery_Accept);
  272.     }
  273.     return(MUIV_DragQuery_Refuse);
  274. }
  275.  
  276.  
  277. ULONG DragString_mDragDrop(struct IClass *cl, Object *obj,
  278.     struct MUIP_DragDrop *msg)
  279. {
  280.     STRPTR ptr;
  281.     if(ptr=(STRPTR)xget(msg->obj, MUIA_String_Contents))
  282.         set(obj, MUIA_String_Contents, (ULONG) ptr);
  283.     else
  284.     {
  285.         struct MetaTypeEntry *entry=NULL;
  286.         DoMethod(msg->obj, MUIM_List_GetEntry, MUIV_List_GetEntry_Active, &entry);
  287.         if (entry)
  288.         {
  289.             struct DragString_Data  *data = INST_DATA(cl, obj);
  290.             switch(data->ObjectID)
  291.             {
  292.                 case DRAGTYPE_METATYPE :
  293.                     set(obj, MUIA_String_Contents, (ULONG) entry->MetaType); break;
  294.                 case DRAGTYPE_TOOL :
  295.                     set(obj, MUIA_String_Contents, (ULONG) entry->Tool); break;
  296.                 case DRAGTYPE_ARGUMENTS :
  297.                     set(obj, MUIA_String_Contents, (ULONG) entry->Arguments); break;
  298.             }
  299.         }
  300.     }
  301.     return(0);
  302. }
  303.  
  304. ULONG DragString_mGet(struct IClass *cl, Object *obj, Msg msg)
  305. {
  306.     struct DragString_Data *data = INST_DATA(cl, obj);
  307.     ULONG *store = ((struct opGet *)msg)->opg_Storage;
  308.  
  309.     switch ( ((struct opGet *)msg)->opg_AttrID )
  310.     {
  311.         case MUIA_DragString_ObjectID: *store = data->ObjectID; break;
  312.     }
  313.     return(DoSuperMethodA(cl, obj, msg));
  314. }
  315.  
  316. ULONG DragString_mNew(struct IClass *cl, Object *obj, struct opSet *msg)
  317. {
  318.     obj=(Object *)DoSuperNew(cl,obj,
  319.         MUIA_Draggable,              TRUE,
  320.         TAG_MORE,                   msg->ops_AttrList);
  321.  
  322.     if(obj)
  323.     {
  324.         struct DragString_Data *data = INST_DATA(cl, obj);
  325.  
  326.         data->ObjectID = (ULONG) GetTagData(MUIA_DragString_ObjectID,
  327.             0, msg->ops_AttrList);
  328.     }
  329.     return((ULONG)obj);
  330. }
  331.  
  332. ULONG __saveds DragString_Dispatcher(register __a0 struct IClass *cl,
  333.                                      register __a2 Object        *obj,
  334.                                      register __a1 Msg           msg)
  335. {
  336.     switch (msg->MethodID)
  337.     {
  338.         case OM_NEW         : return(DragString_mNew       (cl, obj, (APTR)msg));
  339.         case OM_GET         : return(DragString_mGet       (cl, obj, (APTR)msg));
  340.         case MUIM_DragQuery : return(DragString_mDragQuery (cl, obj, (APTR)msg));
  341.         case MUIM_DragDrop  : return(DragString_mDragDrop  (cl, obj, (APTR)msg));
  342.     }
  343.     return(DoSuperMethodA(cl, obj, msg));
  344. }
  345.  
  346. /* MTEntryList Class */
  347.  
  348. struct MTEntryList_Data
  349. {
  350.     struct Hook ConHook, DesHook, CmpHook, DispHook;
  351. };
  352.  
  353. ULONG __saveds MTEntryList_ConFunc(register __a2 APTR pool,
  354.                                    register __a1 struct MetaTypeEntry *entry)
  355. {
  356.     if (entry) {
  357.         struct MetaTypeEntry *newentry;
  358.         if (newentry = AllocMem(sizeof(struct MetaTypeEntry), MEMF_ANY))
  359.         {
  360.             CopyMem(entry, newentry, sizeof(struct MetaTypeEntry));
  361.         }
  362.         return( (int) newentry);
  363.     }
  364.     else
  365.     {
  366.         return(NULL);
  367.     }
  368. }
  369.  
  370. ULONG __saveds MTEntryList_DesFunc(register __a2 APTR pool,
  371.                                    register __a1 struct MetaTypeEntry *entry)
  372. {
  373.     if (entry) FreeMem(entry, sizeof(struct MetaTypeEntry));
  374.     return(NULL);
  375. }
  376.  
  377. ULONG __saveds MTEntryList_DispFunc(register __a2 char **array,
  378.                                     register __a1 struct MetaTypeEntry *entry)
  379.  
  380. {
  381.     if (entry)
  382.     {
  383.         if(strlen(entry->MetaType)>0)
  384.         {
  385.             static char buf[MAXMETATYPELENGTH+4];
  386.             if (entry->FromCD) strcpy(buf, ""); else strcpy(buf, "\33b");
  387.             strcat(buf, entry->MetaType);
  388.             *array++ = buf;
  389.         }
  390.         else *array++ = GetStr(MSG_MTENTRYLIST_WB_NEWENTRY);
  391.         *array++ = (char *) &entry->Tool;
  392.         *array++ = (char *) &entry->Arguments;
  393.         if(entry->WB) *array = GetStr(MSG_MTENTRYLIST_WB_YES);
  394.             else *array = GetStr(MSG_MTENTRYLIST_WB_NO);
  395.     }
  396.     else
  397.     {
  398.         *array++ = GetStr(MSG_MTENTRYLIST_TYPE);
  399.         *array++ = GetStr(MSG_MTENTRYLIST_TOOL);
  400.         *array++ = GetStr(MSG_MTENTRYLIST_ARGUMENTS);
  401.         *array++ = GetStr(MSG_MTENTRYLIST_WB);
  402.     }
  403.     return(0);
  404. }
  405.  
  406. LONG __saveds MTEntryList_CmpFunc(register __a1 struct MetaTypeEntry *entry1,
  407.                                   register __a2 struct MetaTypeEntry *entry2)
  408.  
  409. {
  410.     return(stricmp(entry1->MetaType, entry2->MetaType));
  411. }
  412.  
  413. int GetWord(STRPTR str, int start)
  414. {
  415.     int i;
  416.     i=start; while((*(str+i) != ' ') && (*(str+i) != 9) && (*(str+i) != 10) && (*(str+i) != 0)) i++;
  417.     return(i);
  418. }
  419.  
  420. void CopyItem(STRPTR source, STRPTR dest, int len)
  421. {
  422.     CopyMem(source, dest, len); dest[len] = 0;
  423. }
  424.  
  425. void MTListInsert(Object *list, struct MetaTypeEntry *entry)
  426. {
  427.     LONG entries, i;
  428.     BOOL equal;
  429.     struct  MetaTypeEntry *cmpentry;
  430.  
  431.     get(list, MUIA_List_Entries, &entries); i=0; equal=FALSE;
  432.     while ((i<entries) && (equal == FALSE))
  433.     {
  434.         DoMethod(list, MUIM_List_GetEntry, i, &cmpentry);
  435.         if(cmpentry)
  436.         {
  437.             if(!stricmp(cmpentry->MetaType, entry->MetaType)) equal=TRUE;
  438.         }
  439.         i++;
  440.     }
  441.     if(!equal) DoMethod(list, MUIM_List_InsertSingle, entry, 1,
  442.                         MUIV_List_Insert_Sorted);
  443. }
  444.  
  445. ULONG MTEntryList_Load(struct IClass *cl, Object *obj, struct MUIP_MTEntryList_Load *msg)
  446. {
  447.     BOOL    retval = TRUE;
  448.     APTR    reading;
  449.     BPTR    fh = NULL; STRPTR  linebuf = NULL;
  450.     struct  MetaTypeEntry entry;
  451.     int     cursor, oldcursor, len;
  452.  
  453.     if (!(fh = Open(msg->file, MODE_OLDFILE))) goto exit;
  454.     if (!(linebuf = AllocMem(LINEBUFFERSIZE, MEMF_ANY))) goto exit;
  455.  
  456.     strcpy(entry.Tool, ""); strcpy(entry.Arguments, "");
  457.     entry.FromCD = msg->FromCD; entry.EditWindow=NULL;
  458.  
  459.     while(reading)
  460.     {
  461.         reading = FGets(fh, linebuf, LINEBUFFERSIZE);
  462.         cursor=0; while(*(linebuf+cursor) == ' ') cursor++;
  463.  
  464.         if(reading && (*(linebuf+cursor) != ';') && (*(linebuf+cursor) != 10)
  465.            && (*(linebuf+cursor) != '0')  && (*(linebuf+cursor) != ' '))
  466.         {
  467.             oldcursor=cursor; cursor=GetWord(linebuf, oldcursor);
  468.  
  469.             if((cursor>0) && (cursor<MAXMETATYPELENGTH))
  470.             {
  471.                 CopyItem(linebuf, (STRPTR) &entry.MetaType, cursor); oldcursor=cursor+1;
  472.                 cursor=GetWord(linebuf, oldcursor); len=cursor-oldcursor;
  473.                 if((len>0) && (len<MAXTOOLLENGTH))
  474.                 {
  475.                     CopyItem(linebuf+oldcursor, (STRPTR) &entry.Tool, len); oldcursor=cursor+1;
  476.  
  477.                     entry.WB = TRUE;
  478.                     if (!stricmp(entry.Tool, "CLI"))
  479.                     {
  480.                         cursor=GetWord(linebuf, oldcursor); len=cursor-oldcursor;
  481.                         entry.WB = FALSE;
  482.                         if ((len>0) && (len<MAXTOOLLENGTH))
  483.                         {
  484.                             CopyItem(linebuf+oldcursor, (STRPTR) &entry.Tool, len);
  485.                             oldcursor=cursor+1;
  486.  
  487.                             while((*(linebuf+cursor) != 10) && (*(linebuf+cursor) != 9)
  488.                                   && (*(linebuf+cursor) != ';')) cursor++;
  489.  
  490.                             while(*(linebuf+cursor) == ' ') cursor--;
  491.                             len=cursor-oldcursor;
  492.  
  493.                             if ((len>0) && (len<MAXARGUMENTSLENGTH))
  494.                                 CopyItem(linebuf+oldcursor, (STRPTR) &entry.Arguments, len);
  495.  
  496.                             MTListInsert(obj, &entry);
  497.                         }
  498.                         else
  499.                         {
  500.                             retval = FALSE;
  501.                         }
  502.                         oldcursor=cursor+1;
  503.                     }
  504.                     else
  505.                     {
  506.                         strcpy(entry.Arguments, "");
  507.                         MTListInsert(obj, &entry);
  508.                     }
  509.                 }
  510.                 else
  511.                 {
  512.                     retval = FALSE;
  513.                 }
  514.             }
  515.             else
  516.             {
  517.                 retval = FALSE;
  518.             }
  519.         }
  520.     }
  521.  
  522. exit:
  523.     if (linebuf)    FreeMem(linebuf, LINEBUFFERSIZE);
  524.     if (fh)         Close(fh);
  525.     return(retval);
  526. }
  527.  
  528. ULONG MTEntryList_Save(struct IClass *cl, Object *obj, struct MUIP_MTEntryList_Save *msg)
  529. {
  530.     BPTR    fh = NULL;
  531.     LONG    entries, i=0, res, retval=FALSE;
  532.     struct  MetaTypeEntry *entry;
  533.  
  534.     if(!(fh=Open(msg->file, MODE_NEWFILE))) goto exit;
  535.  
  536.     res=FPrintf(fh, "; MetaTool Configuration File\n; Created by MetaToolPrefs (C) Martin Steigerwald\n\n");
  537.     if (res==-1) goto exit;
  538.  
  539.     get(obj, MUIA_List_Entries, &entries);
  540.     while ((i<entries) && (retval == 0))
  541.     {
  542.         DoMethod(obj, MUIM_List_GetEntry, i,
  543.                  &entry);
  544.         if ((!(entry->FromCD)) && (strlen(entry->MetaType)>0))
  545.         {
  546.             if (entry->WB)
  547.                 res=FPrintf(fh, "%s\t%s\n", (LONG) entry->MetaType, (LONG) entry->Tool);
  548.             else
  549.                 res=FPrintf(fh, "%s\tCLI %s %s\n", (LONG) entry->MetaType,
  550.                             (LONG) entry->Tool, (LONG) entry->Arguments);
  551.             if(res==-1) goto exit;
  552.         }
  553.         i++;
  554.     }
  555.     retval=TRUE;
  556.  
  557. exit:
  558.     if (fh) Close(fh);
  559.     if(!retval) MUI_Request((APTR) xget(obj, MUIA_ApplicationObject),
  560.         (APTR) xget(obj, MUIA_WindowObject), 0, NULL, GetStr(MSG_OK),
  561.         GetStr(MSG_MTENTRYLIST_CANNOTSAVE_ERR));
  562.     return(retval);
  563. }
  564.  
  565. ULONG MTEntryList_mNew(struct IClass *cl, Object * obj, struct opSet *msg)
  566. {
  567.     obj=(Object *)DoSuperNew(cl,obj,
  568.         InputListFrame,
  569.         MUIA_List_Format,           "BAR,BAR,BAR,",
  570.         MUIA_List_Title,            TRUE,
  571.         MUIA_List_DragSortable,     TRUE,
  572.         TAG_MORE,                   msg->ops_AttrList);
  573.  
  574.     if (obj)
  575.     {
  576.         struct MTEntryList_Data *data = INST_DATA(cl, obj);
  577.         data->ConHook.h_Entry  = (VOID *) MTEntryList_ConFunc;
  578.         data->DesHook.h_Entry  = (VOID *) MTEntryList_DesFunc;
  579.         data->CmpHook.h_Entry  = (VOID *) MTEntryList_CmpFunc;
  580.         data->DispHook.h_Entry = (VOID *) MTEntryList_DispFunc;
  581.         set(obj, MUIA_List_CompareHook,   (ULONG) &data->CmpHook);
  582.         set(obj, MUIA_List_ConstructHook, (ULONG) &data->ConHook);
  583.         set(obj, MUIA_List_DestructHook,  (ULONG) &data->DesHook);
  584.         set(obj, MUIA_List_DisplayHook,   (ULONG) &data->DispHook);
  585.     }
  586.     return((ULONG)obj);
  587. }
  588.  
  589. ULONG __saveds MTEntryList_Dispatcher(register __a0 struct IClass *cl,
  590.                                       register __a2 Object        *obj,
  591.                                       register __a1 Msg           msg)
  592. {
  593.     switch (msg->MethodID)
  594.     {
  595.         case OM_NEW                 : return(MTEntryList_mNew  (cl, obj, (APTR)msg));
  596.         case MUIM_MTEntryList_Load  : return(MTEntryList_Load  (cl, obj, (APTR)msg));
  597.         case MUIM_MTEntryList_Save  : return(MTEntryList_Save  (cl, obj, (APTR)msg));
  598.     }
  599.     return(DoSuperMethodA(cl, obj, msg));
  600. }
  601.  
  602. /* MTEditWindow Class */
  603.  
  604. struct MTEditWindow_Data
  605. {
  606.     struct MetaTypeEntry *entry;
  607.     Object *Originator;
  608.     Object *MetaTypePop, *MetaTypeString, *MetaTypeList;
  609.     Object *ToolPop, *ToolString;
  610.     Object *ArgumentsString, *WBBut;
  611.     struct Hook StrObjHook, ObjStrHook, WindowHook;
  612. };
  613.  
  614. /* support functions */
  615.  
  616. ULONG __saveds StrObjFunc(register __a2 Object *pop,
  617.                           register __a1 Object *str)
  618. {
  619.     char *x,*s; int i;
  620.  
  621.     get(str, MUIA_String_Contents,&s);
  622.  
  623.     for (i=0;;i++)
  624.     {
  625.         DoMethod(pop, MUIM_List_GetEntry, i, &x);
  626.         if (!x)
  627.         {
  628.             set(pop,MUIA_List_Active, MUIV_List_Active_Off);
  629.             break;
  630.         }
  631.         else if (!stricmp(x,s))
  632.         {
  633.             set(pop, MUIA_List_Active,i);
  634.             break;
  635.         }
  636.     }
  637.     return(TRUE);
  638. }
  639.  
  640. ULONG __saveds ObjStrFunc(register __a2 Object *pop,
  641.                           register __a1 Object *str)
  642. {
  643.     char *x;
  644.  
  645.     DoMethod(pop, MUIM_List_GetEntry, MUIV_List_GetEntry_Active, &x);
  646.     set(str, MUIA_String_Contents, (ULONG) x);
  647.     return(0);
  648. }
  649.  
  650. ULONG __saveds WindowFunc(register __a2 Object *pop,
  651.                           register __a1 Object *win)
  652. {
  653.     set(win, MUIA_Window_DefaultObject, (ULONG) pop);
  654.     return(0);
  655. }
  656.  
  657. /* class functions */
  658.  
  659. ULONG MTEditWindow_UpdateGadgets(struct IClass *cl, Object *obj, Msg msg)
  660. {
  661.     struct MTEditWindow_Data *data = INST_DATA(cl, obj);
  662.  
  663.     if(data->entry)
  664.     {
  665.         nnset(data->MetaTypeString, MUIA_String_Contents, (ULONG) data->entry->MetaType);
  666.         nnset(data->ToolString, MUIA_String_Contents, (ULONG) data->entry->Tool);
  667.         nnset(data->ArgumentsString, MUIA_String_Contents, (ULONG) data->entry->Arguments);
  668.         nnset(data->WBBut, MUIA_Selected, data->entry->WB);
  669.         DoMethod(data->ArgumentsString, MUIM_Set, MUIA_Disabled, data->entry->WB);
  670.     }
  671.     return(0);
  672. }
  673.  
  674. ULONG MTEditWindow_UpdateEntry(struct IClass *cl, Object *obj,
  675.     struct MUIP_MTEditWindow_UpdateEntry *msg)
  676. {
  677.     struct MTEditWindow_Data *data = INST_DATA(cl, obj);
  678.     STRPTR arg;
  679.  
  680.     if(data->entry)
  681.     {
  682.         data->entry->FromCD = FALSE;
  683.         switch (msg->mode)
  684.         {
  685.             case MODE_CHANGE_METATYPE:
  686.                 get(data->MetaTypeString, MUIA_String_Contents, &arg);
  687.                 strcpy(data->entry->MetaType, arg); break;
  688.             case MODE_CHANGE_TOOL:
  689.                 get(data->ToolString, MUIA_String_Contents, &arg);
  690.                 strcpy(data->entry->Tool, arg); break;
  691.             case MODE_CHANGE_ARGUMENTS:
  692.                 get(data->ArgumentsString, MUIA_String_Contents, &arg);
  693.                 strcpy(data->entry->Arguments, arg); break;
  694.             case MODE_CHANGE_WB:
  695.                 if (data->entry->WB) data->entry->WB=FALSE; else data->entry->WB=TRUE;
  696.        }
  697.        DoMethod((Object *)xget(obj, MUIA_ApplicationObject), MUIM_Application_PushMethod,
  698.            data->Originator, 2, MUIM_MTEntryPanel_UpdateEntry, data->entry);
  699.     }
  700.     return(0);
  701. }
  702.  
  703.           /*
  704. ULONG MTEditWindow_mDragQuery(struct IClass *cl, Object *obj,
  705.     struct MUIP_DragQuery *msg)
  706. {
  707.         return(MUIV_DragQuery_Accept);
  708.  
  709.     if (msg->obj==obj)
  710.        return(MUIV_DragQuery_Refuse);
  711.     {
  712.         struct MetaTypeEntry *entry=NULL;
  713.         DoMethod(msg->obj, MUIM_List_GetEntry, MUIV_List_GetEntry_Active,
  714.             &entry);
  715.         if(entry)
  716.         return(MUIV_DragQuery_Accept);
  717.     }
  718.     return(MUIV_DragQuery_Refuse);
  719. }
  720.  
  721.  
  722. ULONG MTEditWindow_mDragDrop(struct IClass *cl, Object *obj,
  723.     struct MUIP_DragDrop *msg)
  724. {
  725.     struct MetaTypeEntry *entry=NULL;
  726.     DoMethod(msg->obj, MUIM_List_GetEntry, MUIV_List_GetEntry_Active, &entry);
  727.     if (entry)
  728.     {
  729.         struct MTEditWindow_Data *data = INST_DATA(cl, obj);
  730.         set(data->MetaTypeString, MUIA_String_Contents, (ULONG) entry->MetaType);
  731.         set(data->ToolString, MUIA_String_Contents, (ULONG) entry->Tool);
  732.         set(data->ArgumentsString, MUIA_String_Contents, (ULONG) entry->Arguments);
  733.     }
  734.     return(0);
  735. }
  736. */
  737.  
  738. ULONG MTEditWindow_mGet(struct IClass *cl, Object *obj, struct opGet *msg)
  739. {
  740.     struct MTEditWindow_Data *data = INST_DATA(cl, obj);
  741.     ULONG *store = msg->opg_Storage;
  742.  
  743.     switch (msg->opg_AttrID)
  744.     {
  745.         case MUIA_MTEditWindow_CloseAble:
  746.             *store = !(xget(data->ToolPop, MUIA_Popasl_Active)); return(TRUE);
  747.     }
  748.     return(DoSuperMethodA(cl, obj, (Msg) msg));
  749. }
  750.  
  751. ULONG MTEditWindow_mNew(struct IClass *cl, Object *obj, struct opSet *msg)
  752. {
  753.     struct MTEditWindow_Data tmp = {0};
  754.  
  755.     obj = (Object *)DoSuperNew(cl, obj,
  756.         WindowContents, VGroup,
  757.             Child, ColGroup(2),
  758.                 Child, Label2(GetStr(MSG_MTEDITWINDOW_METATYPE_GAD)),
  759.                 Child, tmp.MetaTypePop = PopobjectObject,
  760.                     MUIA_Popstring_String,      tmp.MetaTypeString =
  761.                         (Object *)NewObject(DragString_Class->mcc_Class, NULL,
  762.                         StringFrame,
  763.                         MUIA_String_MaxLen,     MAXMETATYPELENGTH,
  764.                         MUIA_DragString_ObjectID,     DRAGTYPE_METATYPE),
  765.                     MUIA_Popstring_Button,      PopButton(MUII_PopUp),
  766.                     MUIA_Popobject_Object,  tmp.MetaTypeList = ListviewObject,
  767.                         MUIA_Listview_List, ListObject,
  768.                             InputListFrame,
  769.                             MUIA_List_SourceArray, MetaTypeNames,
  770.                         End,
  771.                     End,
  772.                 End,
  773.                 Child, Label2(GetStr(MSG_MTEDITWINDOW_TOOL_GAD)),
  774.                 Child, tmp.ToolPop = PopaslObject,
  775.                     MUIA_Popstring_String, tmp.ToolString =
  776.                         (Object *)NewObject(DragString_Class->mcc_Class, NULL,
  777.                         StringFrame,
  778.                         MUIA_String_MaxLen,     MAXTOOLLENGTH,
  779.                         MUIA_DragString_ObjectID,     DRAGTYPE_TOOL),
  780.                     MUIA_Popstring_Button, PopButton(MUII_PopFile),
  781.                     ASLFR_TitleText,       GetStr(MSG_MTEDITWINDOW_TOOL_FREQ),
  782.                     ASLFR_RejectIcons,     TRUE,
  783.                 End,
  784.                 Child, Label2(GetStr(MSG_MTEDITWINDOW_ARGUMENTS_GAD)),
  785.                 Child, tmp.ArgumentsString =
  786.                         (Object *)NewObject(DragString_Class->mcc_Class, NULL,
  787.                         StringFrame,
  788.                         MUIA_String_MaxLen,     MAXARGUMENTSLENGTH,
  789.                         MUIA_DragString_ObjectID,     DRAGTYPE_ARGUMENTS),
  790.             End,
  791.             Child, HGroup,
  792.                 Child, HSpace(0),
  793.                 Child, Label2(GetStr(MSG_MTEDITWINDOW_WB_GAD)),
  794.                 Child, tmp.WBBut = CheckMark(FALSE),
  795.             End,
  796.         End,
  797.         TAG_MORE, msg->ops_AttrList);
  798.  
  799.     if (obj)
  800.     {
  801.         struct MTEditWindow_Data *data = INST_DATA(cl, obj);
  802.  
  803.         tmp.entry = (struct MetaTypeEntry *)GetTagData(MUIA_MTEditWindow_Entry,
  804.             0, msg->ops_AttrList);
  805.         tmp.Originator = (Object *)GetTagData(MUIA_MTEditWindow_Originator,
  806.             0, msg->ops_AttrList);
  807.  
  808.         tmp.StrObjHook.h_Entry = (VOID *) StrObjFunc;
  809.         tmp.ObjStrHook.h_Entry = (VOID *) ObjStrFunc;
  810.         tmp.WindowHook.h_Entry = (VOID *) WindowFunc;
  811.  
  812.         *data = tmp;
  813.  
  814.         DoMethod(obj, MUIM_Notify, MUIA_Window_CloseRequest, TRUE,
  815.                  MUIV_Notify_Application, 5, MUIM_Application_PushMethod,
  816.                  tmp.Originator, 2, MUIM_MTEntryPanel_QuitEdit, tmp.entry );
  817.  
  818.         DoMethod(tmp.MetaTypeString, MUIM_Notify, MUIA_String_Contents, MUIV_EveryTime,
  819.                  obj, 2, MUIM_MTEditWindow_UpdateEntry, MODE_CHANGE_METATYPE);
  820.         DoMethod(tmp.ToolString, MUIM_Notify, MUIA_String_Contents, MUIV_EveryTime,
  821.                  obj, 2, MUIM_MTEditWindow_UpdateEntry, MODE_CHANGE_TOOL);
  822.         DoMethod(tmp.ArgumentsString, MUIM_Notify, MUIA_String_Contents, MUIV_EveryTime,
  823.                  obj, 2, MUIM_MTEditWindow_UpdateEntry, MODE_CHANGE_ARGUMENTS);
  824.         DoMethod(tmp.WBBut, MUIM_Notify, MUIA_Selected, MUIV_EveryTime,
  825.                  obj, 2, MUIM_MTEditWindow_UpdateEntry, MODE_CHANGE_WB);
  826.  
  827.         DoMethod(tmp.WBBut, MUIM_Notify, MUIA_Selected, TRUE,
  828.                  tmp.ArgumentsString, 3, MUIM_Set, MUIA_Disabled, TRUE);
  829.  
  830.         DoMethod(tmp.WBBut, MUIM_Notify, MUIA_Selected, FALSE,
  831.                  tmp.ArgumentsString, 3, MUIM_Set, MUIA_Disabled, FALSE);
  832.  
  833.         DoMethod(tmp.MetaTypeList, MUIM_Notify, MUIA_Listview_DoubleClick, TRUE,
  834.                  tmp.MetaTypePop, 2, MUIM_Popstring_Close, TRUE);
  835.  
  836.         DoMethod(obj, MUIM_Window_SetCycleChain, tmp.MetaTypePop, tmp.ToolPop,
  837.                  tmp.ArgumentsString, tmp.WBBut, NULL);
  838.  
  839.         set(tmp.MetaTypePop, MUIA_Popobject_StrObjHook, (ULONG) &data->StrObjHook);
  840.         set(tmp.MetaTypePop, MUIA_Popobject_ObjStrHook, (ULONG) &data->ObjStrHook);
  841.         set(tmp.MetaTypePop, MUIA_Popobject_WindowHook, (ULONG) &data->WindowHook);
  842.  
  843.         set(tmp.MetaTypePop,     MUIA_ShortHelp,
  844.             (ULONG) GetStr(MSG_MTEDITWINDOW_METATYPE_GAD_HELP));
  845.         set(tmp.ToolPop,         MUIA_ShortHelp,
  846.             (ULONG) GetStr(MSG_MTEDITWINDOW_TOOL_GAD_HELP));
  847.         set(tmp.ArgumentsString, MUIA_ShortHelp,
  848.             (ULONG) GetStr(MSG_MTEDITWINDOW_ARGUMENTS_GAD_HELP));
  849.         set(tmp.WBBut,           MUIA_ShortHelp,
  850.             (ULONG) GetStr(MSG_MTEDITWINDOW_WB_GAD_HELP));
  851.  
  852.         set(obj, MUIA_Window_ActiveObject, (ULONG)tmp.ToolPop);
  853.  
  854.         DoMethod(obj, MUIM_MTEditWindow_UpdateGadgets);
  855.  
  856.     }
  857.     return((ULONG)obj);
  858. }
  859.  
  860. ULONG __saveds MTEditWindow_Dispatcher(register __a0 struct IClass *cl,
  861.                                        register __a2 Object        *obj,
  862.                                        register __a1 Msg           msg)
  863. {
  864.     switch (msg->MethodID)
  865.     {
  866.         case OM_NEW                             : return(MTEditWindow_mNew     (cl, obj, (APTR)msg));
  867.         case OM_GET                             : return(MTEditWindow_mGet     (cl, obj, (APTR)msg));
  868.         /*
  869.         case MUIM_DragQuery                     : return(MTEditWindow_mDragQuery (cl, obj, (APTR)msg));
  870.         case MUIM_DragDrop                      : return(MTEditWindow_mDragDrop  (cl, obj, (APTR)msg));
  871.         */
  872.         case MUIM_MTEditWindow_UpdateGadgets    : return(MTEditWindow_UpdateGadgets (cl, obj, (APTR)msg));
  873.         case MUIM_MTEditWindow_UpdateEntry      : return(MTEditWindow_UpdateEntry (cl, obj, (APTR)msg));
  874.     }
  875.     return(DoSuperMethodA(cl, obj, msg));
  876. }
  877.  
  878.  
  879. /* MTEntryPanel Class */
  880.  
  881.  
  882. struct MTEntryPanel_Data
  883. {
  884.     Object  *Listview, *ContextMenu;
  885.     Object  *EditBut, *SortBut, *NewBut, *RemoveBut;
  886. };
  887.  
  888. ULONG MTEntryPanel_ToggleEdit(Object *obj, struct MetaTypeEntry *entry)
  889. {
  890.     if(entry)
  891.     {
  892.         if(entry->EditWindow)
  893.             DoMethod(obj, MUIM_MTEntryPanel_QuitEdit, entry);
  894.         else
  895.         {
  896.             entry->EditWindow=(Object *)NewObject(MTEditWindow_Class->mcc_Class, NULL,
  897.                 MUIA_Window_Title,              (ULONG) GetStr(MSG_MTEDITWINDOW_TITLE),
  898.                 MUIA_Window_ScreenTitle,        (ULONG) GetStr(MSG_APP_TITLE),
  899.                 MUIA_Window_ID,
  900.                     MAKE_ID(entry->MetaType[0], entry->MetaType[1],
  901.                         entry->MetaType[2], entry->MetaType[3]),
  902.                 MUIA_MTEditWindow_Entry,        (ULONG) entry,
  903.                 MUIA_MTEditWindow_Originator,   (ULONG) obj,
  904.                 TAG_DONE);
  905.             if(entry->EditWindow)
  906.             {
  907.                 DoMethod((Object *)xget(obj, MUIA_ApplicationObject),
  908.                     OM_ADDMEMBER, entry->EditWindow);
  909.                 set(entry->EditWindow, MUIA_Window_Open, TRUE);
  910.             }
  911.         }
  912.     }
  913.     return(0);
  914. }
  915.  
  916. ULONG MTEntryPanel_Edit(struct IClass *cl, Object *obj,
  917.     struct MUIP_MTEntryPanel_Edit *msg )
  918. {
  919.     struct MTEntryPanel_Data *data = INST_DATA(cl, obj);
  920.     struct MetaTypeEntry *entry; LONG entrynum=MUIV_List_NextSelected_Start;
  921.  
  922.     set((Object *)xget(obj, MUIA_ApplicationObject), MUIA_Application_Sleep, TRUE);
  923.  
  924.     switch(msg->TriggerValue)
  925.     {
  926.         case MTEntryPanel_Edit_Active:
  927.         {
  928.             DoMethod(data->Listview, MUIM_List_GetEntry, MUIV_List_GetEntry_Active, &entry);
  929.             MTEntryPanel_ToggleEdit(obj, entry); break;
  930.         }
  931.         case MTEntryPanel_Edit_Selected:
  932.         {
  933.             for(;;)
  934.             {
  935.                 DoMethod(data->Listview, MUIM_List_NextSelected, &entrynum);
  936.                 if (entrynum==MUIV_List_NextSelected_End) break;
  937.                 DoMethod(data->Listview, MUIM_List_GetEntry, entrynum, &entry);
  938.                 MTEntryPanel_ToggleEdit(obj, entry);
  939.             }
  940.             break;
  941.         }
  942.     }
  943.     set((Object *)xget(obj, MUIA_ApplicationObject), MUIA_Application_Sleep, FALSE);
  944.  
  945.     return(0);
  946. }
  947.  
  948. ULONG MTEntryPanel_QuitEdit(struct IClass *cl, Object *obj,
  949.     struct MUIP_MTEntryPanel_QuitEdit *msg)
  950. {
  951.     if(msg->entry)
  952.     {
  953.         if(msg->entry->EditWindow)
  954.         {
  955.             if (xget(msg->entry->EditWindow, MUIA_MTEditWindow_CloseAble))
  956.             {
  957.                 set(msg->entry->EditWindow, MUIA_Window_Open, FALSE);
  958.                 DoMethod((Object *)xget(msg->entry->EditWindow, MUIA_ApplicationObject),
  959.                     OM_REMMEMBER, msg->entry->EditWindow);
  960.                 MUI_DisposeObject(msg->entry->EditWindow);
  961.                 msg->entry->EditWindow=NULL;
  962.             }
  963.             else
  964.             {
  965.                 MUI_Request((APTR)xget(obj, MUIA_ApplicationObject), msg->entry->EditWindow,
  966.                 0, NULL, GetStr(MSG_OK), GetStr(MSG_MTENTRYPANEL_CANNOTCLOSE_ERR));
  967.             }
  968.         }
  969.     }
  970.     return(0);
  971. }
  972.  
  973. ULONG MTEntryPanel_QuitEditAll(struct IClass *cl, Object *obj, Msg *msg)
  974. {
  975.     struct MTEntryPanel_Data *data = INST_DATA(cl, obj);
  976.     struct MetaTypeEntry *entry;
  977.     LONG i, entries;
  978.  
  979.     set((Object *)xget(obj, MUIA_ApplicationObject), MUIA_Application_Sleep, TRUE);
  980.     entries=xget(data->Listview, MUIA_List_Entries);
  981.  
  982.     for(i=0; i<entries; i++)
  983.     {
  984.         DoMethod(data->Listview, MUIM_List_GetEntry, i, &entry);
  985.         if(entry->EditWindow) DoMethod(obj, MUIM_MTEntryPanel_QuitEdit, entry);
  986.     }
  987.     set((Object *)xget(obj, MUIA_ApplicationObject), MUIA_Application_Sleep, FALSE);
  988.     return(0);
  989. }
  990.  
  991. ULONG MTEntryPanel_UpdateEntry(struct IClass *cl, Object *obj,
  992.     struct MUIP_MTEntryPanel_UpdateEntry *msg)
  993. {
  994.     struct MTEntryPanel_Data *data = INST_DATA(cl, obj);
  995.     struct  MetaTypeEntry *entry;
  996.     LONG i,entries;
  997.     BOOL equal;
  998.  
  999.     if(msg->entry)
  1000.     {
  1001.         entries=xget(data->Listview, MUIA_List_Entries);
  1002.         i=0; equal=FALSE;
  1003.         while ((i<entries) && (equal == FALSE))
  1004.         {
  1005.             DoMethod(data->Listview, MUIM_List_GetEntry, i, &entry);
  1006.             if(msg->entry==entry) equal = TRUE; else i++;
  1007.         }
  1008.         DoMethod(data->Listview, MUIM_List_Redraw, i);
  1009.     }
  1010.     return(0);
  1011. }
  1012.  
  1013. ULONG MTEntryPanel_New(struct IClass *cl, Object *obj, Msg msg)
  1014. {
  1015.     struct MTEntryPanel_Data *data = INST_DATA(cl, obj);
  1016.     struct MetaTypeEntry entry;
  1017.  
  1018.     set((Object *)xget(obj, MUIA_ApplicationObject), MUIA_Application_Sleep, TRUE);
  1019.  
  1020.     strcpy(entry.MetaType, ""); strcpy(entry.Tool, ""); strcpy(entry.Arguments, "");
  1021.     entry.WB = FALSE; entry.FromCD = FALSE; entry.EditWindow = NULL;
  1022.  
  1023.     DoMethod((APTR)data->Listview, MUIM_List_InsertSingle, &entry, MUIV_List_Insert_Bottom);
  1024.     set((APTR)data->Listview, MUIA_List_Active, MUIV_List_Active_Bottom);
  1025.     DoMethod((Object *)xget(obj, MUIA_ApplicationObject), MUIM_Application_PushMethod,
  1026.         obj, 2, MUIM_MTEntryPanel_Edit, MTEntryPanel_Edit_Active);
  1027.     set((Object *)xget(obj, MUIA_ApplicationObject), MUIA_Application_Sleep, FALSE);
  1028.     return(NULL);
  1029. }
  1030.  
  1031. ULONG MTEntryPanel_Sort(struct IClass *cl, Object *obj, Msg msg)
  1032. {
  1033.     struct MTEntryPanel_Data *data = INST_DATA(cl, obj);
  1034.     DoMethod(data->Listview, MUIM_List_Sort);
  1035.     return(0);
  1036. }
  1037.  
  1038. ULONG MTEntryPanel_Remove(struct IClass *cl, Object *obj, Msg msg)
  1039. {
  1040.     struct MTEntryPanel_Data *data = INST_DATA(cl, obj);
  1041.     struct MetaTypeEntry *entry;
  1042.     LONG id = MUIV_List_NextSelected_Start;
  1043.  
  1044.     set((Object *)xget(obj, MUIA_ApplicationObject), MUIA_Application_Sleep, TRUE);
  1045.     for (;;)
  1046.     {
  1047.         DoMethod(data->Listview,MUIM_List_NextSelected,&id);
  1048.         if (id==MUIV_List_NextSelected_End) break;
  1049.         DoMethod(data->Listview,MUIM_List_GetEntry,id,&entry);
  1050.  
  1051.         // Nur schließen und entfernen, wenn es schließbar ist
  1052.         if (entry)
  1053.         {
  1054.             if (entry->EditWindow)
  1055.             {
  1056.                 if (xget(entry->EditWindow, MUIA_MTEditWindow_CloseAble))
  1057.                 {
  1058.                     DoMethod(obj, MUIM_MTEntryPanel_QuitEdit, entry);
  1059.                     DoMethod(data->Listview, MUIM_List_Remove, id);
  1060.                 } // CloseAble?
  1061.                 else
  1062.                 {
  1063.                     MUI_Request((APTR)xget(obj, MUIA_ApplicationObject), NULL,
  1064.                     0, NULL, GetStr(MSG_OK), GetStr(MSG_MTENTRYPANEL_CANNOTREMOVE_ERR));
  1065.                 }
  1066.             }
  1067.             else
  1068.             {
  1069.                 DoMethod(data->Listview, MUIM_List_Remove, id);
  1070.             } // EditWindow?
  1071.         } // entry
  1072.     }
  1073.     // Do not close all selected anymore!!! To avoid closing uncloseable editwindows
  1074.     // DoMethod(data->Listview, MUIM_List_Remove, MUIV_List_Remove_Selected);
  1075.     set((Object *)xget(obj, MUIA_ApplicationObject), MUIA_Application_Sleep, FALSE);
  1076.     return(0);
  1077. }
  1078.  
  1079. ULONG MTEntryPanel_CheckConfig(struct IClass *cl, Object *obj, Msg msg)
  1080. {
  1081.     if (!DOSPathBase) DOSPathBase=OpenLibrary(DOSPATH_NAME, DOSPATH_VERSION);
  1082.  
  1083.     if (DOSPathBase)
  1084.     {
  1085.         struct MTEntryPanel_Data *data = INST_DATA(cl, obj);
  1086.         struct MetaTypeEntry *entry;
  1087.         BOOL   wbmode = FALSE;
  1088.         struct Process *myprocess = (struct Process *) FindTask(NULL);
  1089.         struct PathListEntry *path=NULL;
  1090.         APTR   winptr;
  1091.  
  1092.         if (WBenchMsg)
  1093.         {
  1094.             path = CopyWorkbenchPathList(WBenchMsg, NULL); wbmode = TRUE;
  1095.         }
  1096.         else
  1097.             path = GetProcessPathList(myprocess);
  1098.  
  1099.         if (path)
  1100.         {
  1101.             LONG i, entries;
  1102.             set((Object *)xget(obj, MUIA_ApplicationObject), MUIA_Application_Sleep, TRUE);
  1103.             set(data->Listview, MUIA_List_Quiet, TRUE);
  1104.             winptr=myprocess->pr_WindowPtr; myprocess->pr_WindowPtr=(APTR) -1;
  1105.  
  1106.             entries=xget(data->Listview, MUIA_List_Entries);
  1107.             for(i=0; i<entries; i++)
  1108.             {
  1109.                 struct PathListEntry *state = path;
  1110.                 DoMethod(data->Listview, MUIM_List_GetEntry, i, &entry);
  1111.                 if(entry)
  1112.                 {
  1113.                     if(FindFileInPathList(&state, entry->Tool))
  1114.                         DoMethod(data->Listview, MUIM_List_Select, i,
  1115.                             MUIV_List_Select_Off, NULL);
  1116.                     else
  1117.                         DoMethod(data->Listview, MUIM_List_Select, i,
  1118.                             MUIV_List_Select_On, NULL);
  1119.                 }
  1120.             }
  1121.  
  1122.             myprocess->pr_WindowPtr=winptr;  if(wbmode && path) FreePathList(path);
  1123.             set(data->Listview, MUIA_List_Quiet, FALSE);
  1124.             set((Object *)xget(obj, MUIA_ApplicationObject), MUIA_Application_Sleep, FALSE);
  1125.         }
  1126.     }
  1127.     else
  1128.     {
  1129.         MUI_Request((APTR)xget(obj, MUIA_ApplicationObject), (APTR) xget(obj, MUIA_WindowObject),
  1130.             0, NULL, GetStr(MSG_OK), GetStr(MSG_MTENTRYPANEL_CANNOTCHECKCONFIG));
  1131.     }
  1132.     return(0);
  1133. }
  1134.  
  1135. ULONG MTEntryPanel_SetSave(struct IClass *cl, Object *obj,
  1136.     struct MUIP_MTEntryPanel_SetSave *msg)
  1137. {
  1138.     struct  MTEntryPanel_Data *data = INST_DATA(cl, obj);
  1139.     struct  MetaTypeEntry *entry; BOOL FromCD;
  1140.     LONG    id = MUIV_List_NextSelected_Start;
  1141.  
  1142.     if(msg->mode==MTEntryPanel_SetSave_Set) FromCD=FALSE; else FromCD=TRUE;
  1143.  
  1144.     set((Object *)xget(obj, MUIA_ApplicationObject), MUIA_Application_Sleep, TRUE);
  1145.     set(data->Listview, MUIA_List_Quiet, TRUE);
  1146.     for (;;)
  1147.     {
  1148.         DoMethod(data->Listview,MUIM_List_NextSelected,&id);
  1149.         if (id==MUIV_List_NextSelected_End) break;
  1150.         DoMethod(data->Listview,MUIM_List_GetEntry,id,&entry);
  1151.         if(entry)
  1152.         {
  1153.             entry->FromCD=FromCD;
  1154.             DoMethod(data->Listview, MUIM_List_Redraw, id);
  1155.         }
  1156.     }
  1157.     set(data->Listview, MUIA_List_Quiet, FALSE);
  1158.     set((Object *)xget(obj, MUIA_ApplicationObject), MUIA_Application_Sleep, FALSE);
  1159.     return(0);
  1160. }
  1161.  
  1162.  
  1163. ULONG MTEntryPanel_ContextMenuChoice(struct IClass *cl, Object *obj,
  1164.     struct MUIP_ContextMenuChoice *msg)
  1165. {
  1166.     struct  MTEntryPanel_Data *data = INST_DATA(cl, obj);
  1167.  
  1168.     switch(muiUserData(msg->item))
  1169.     {
  1170.         case MEN_MTENTRYPANEL_SELECT_ALL :
  1171.             DoMethod(data->Listview, MUIM_List_Select, MUIV_List_Select_All,
  1172.                 MUIV_List_Select_On, NULL); break;
  1173.         case MEN_MTENTRYPANEL_DESELECT_ALL :
  1174.             DoMethod(data->Listview, MUIM_List_Select, MUIV_List_Select_All,
  1175.                 MUIV_List_Select_Off, NULL); break;
  1176.         case MEN_MTENTRYPANEL_TOGGLE_ALL :
  1177.             DoMethod(data->Listview, MUIM_List_Select, MUIV_List_Select_All,
  1178.                 MUIV_List_Select_Toggle, NULL); break;
  1179.         case MEN_MTENTRYPANEL_CHECKCONFIG :
  1180.             DoMethod(obj, MUIM_MTEntryPanel_CheckConfig); break;
  1181.         case MEN_MTENTRYPANEL_SETSAVE :
  1182.             DoMethod(obj, MUIM_MTEntryPanel_SetSave, MTEntryPanel_SetSave_Set); break;
  1183.         case MEN_MTENTRYPANEL_UNSETSAVE :
  1184.             DoMethod(obj, MUIM_MTEntryPanel_SetSave, MTEntryPanel_SetSave_UnSet); break;
  1185.         case MEN_MTENTRYPANEL_CLOSE_ALL :
  1186.             DoMethod(obj, MUIM_MTEntryPanel_QuitEditAll); break;
  1187.     }
  1188.     return(0);
  1189. }
  1190.  
  1191. ULONG MTEntryPanel_mGet(struct IClass *cl, Object *obj, struct opGet *msg)
  1192. {
  1193.     struct MTEntryPanel_Data *data = INST_DATA(cl, obj);
  1194.     ULONG *store = msg->opg_Storage;
  1195.  
  1196.     switch (msg->opg_AttrID)
  1197.     {
  1198.         case MUIA_MTEntryPanel_CloseAble:
  1199.         {
  1200.             struct MetaTypeEntry *entry;
  1201.             LONG i, entries; LONG CloseAble=TRUE;
  1202.  
  1203.             set((Object *)xget(obj, MUIA_ApplicationObject), MUIA_Application_Sleep, TRUE);
  1204.             entries=xget(data->Listview, MUIA_List_Entries);
  1205.  
  1206.             for(i=0; (i<entries) && CloseAble; i++)
  1207.             {
  1208.                 DoMethod(data->Listview, MUIM_List_GetEntry, i, &entry);
  1209.                 if(entry->EditWindow)
  1210.                     CloseAble=xget(entry->EditWindow, MUIA_MTEditWindow_CloseAble);
  1211.             }
  1212.             set((Object *)xget(obj, MUIA_ApplicationObject), MUIA_Application_Sleep, FALSE);
  1213.             *store = CloseAble; return(TRUE);
  1214.         }
  1215.     }
  1216.     return(DoSuperMethodA(cl, obj, (Msg) msg));
  1217. }
  1218.  
  1219. ULONG MTEntryPanel_mNew(struct IClass *cl, Object *obj, struct opSet *msg)
  1220. {
  1221.     struct MTEntryPanel_Data tmp = {0};
  1222.  
  1223.     obj = (Object *)DoSuperNew(cl, obj,
  1224.         MUIA_ContextMenu,   tmp.ContextMenu = MUI_MakeObject(MUIO_MenustripNM,
  1225.             MTEntryPanelMenu, MUIO_MenustripNM_CommandKeyCheck),
  1226.  
  1227.         Child, tmp.Listview = ListviewObject,
  1228.             MUIA_Listview_Input,        TRUE,
  1229.             MUIA_Listview_DragType,     MUIV_Listview_DragType_Immediate,
  1230.             MUIA_Listview_MultiSelect,  MUIV_Listview_MultiSelect_Default,
  1231.             MUIA_Listview_List,
  1232.                 (Object *) NewObject(MTEntryList_Class->mcc_Class, NULL, TAG_DONE),
  1233.         End,
  1234.         Child, HGroup,
  1235.             Child, tmp.EditBut      = SimpleButton(GetStr(MSG_MTENTRYPANEL_EDIT_GAD)),
  1236.             Child, tmp.NewBut       = SimpleButton(GetStr(MSG_MTENTRYPANEL_NEW_GAD)),
  1237.             Child, tmp.SortBut      = SimpleButton(GetStr(MSG_MTENTRYPANEL_SORT_GAD)),
  1238.             Child, tmp.RemoveBut    = SimpleButton(GetStr(MSG_MTENTRYPANEL_REMOVE_GAD)),
  1239.         End,
  1240.         TAG_MORE, msg->ops_AttrList);
  1241.  
  1242.     if (obj)
  1243.     {
  1244.         struct MTEntryPanel_Data *data = INST_DATA(cl, obj);
  1245.         *data = tmp;
  1246.  
  1247.         DoMethod(tmp.Listview, MUIM_Notify, MUIA_Listview_DoubleClick, TRUE,
  1248.                  obj, 2, MUIM_MTEntryPanel_Edit, MTEntryPanel_Edit_Active);
  1249.         DoMethod(tmp.EditBut, MUIM_Notify, MUIA_Pressed, FALSE,
  1250.                  obj, 2, MUIM_MTEntryPanel_Edit, MTEntryPanel_Edit_Selected);
  1251.         DoMethod(tmp.NewBut, MUIM_Notify, MUIA_Pressed, FALSE,
  1252.                  obj, 1, MUIM_MTEntryPanel_New);
  1253.         DoMethod(tmp.SortBut, MUIM_Notify, MUIA_Pressed, FALSE,
  1254.                  data->Listview, 1, MUIM_List_Sort);
  1255.         DoMethod(tmp.RemoveBut, MUIM_Notify, MUIA_Pressed, FALSE,
  1256.                  obj, 1, MUIM_MTEntryPanel_Remove );
  1257.  
  1258.         set(tmp.EditBut,   MUIA_ShortHelp, (ULONG) GetStr(MSG_MTENTRYPANEL_EDIT_GAD_HELP));
  1259.         set(tmp.NewBut,    MUIA_ShortHelp, (ULONG) GetStr(MSG_MTENTRYPANEL_NEW_GAD_HELP));
  1260.         set(tmp.SortBut,   MUIA_ShortHelp, (ULONG) GetStr(MSG_MTENTRYPANEL_SORT_GAD_HELP));
  1261.         set(tmp.RemoveBut, MUIA_ShortHelp, (ULONG) GetStr(MSG_MTENTRYPANEL_REMOVE_GAD_HELP));
  1262.         set(tmp.Listview,  MUIA_ShortHelp, (ULONG) GetStr(MSG_MTENTRYPANEL_LISTVIEW_HELP));
  1263.     }
  1264.     return((ULONG)obj);
  1265. }
  1266.  
  1267. ULONG MTEntryPanel_mDispose(struct IClass *cl, Object *obj, Msg msg)
  1268. {
  1269.     struct MTEntryPanel_Data *data = INST_DATA(cl, obj);
  1270.     if (data->ContextMenu) MUI_DisposeObject(data->ContextMenu);
  1271.     return(DoSuperMethodA(cl, obj, (APTR) msg));
  1272. }
  1273.  
  1274. ULONG __saveds MTEntryPanel_Dispatcher(register __a0 struct IClass *cl,
  1275.                                        register __a2 Object        *obj,
  1276.                                        register __a1 Msg           msg)
  1277. {
  1278.     switch (msg->MethodID)
  1279.     {
  1280.         case OM_NEW                        : return(MTEntryPanel_mNew        (cl, obj, (APTR)msg));
  1281.         case OM_DISPOSE                    : return(MTEntryPanel_mDispose    (cl, obj, (APTR)msg));
  1282.         case OM_GET                        : return(MTEntryPanel_mGet        (cl, obj, (APTR)msg));
  1283.         case MUIM_ContextMenuChoice        : return(MTEntryPanel_ContextMenuChoice (cl, obj, (APTR)msg));
  1284.         case MUIM_MTEntryPanel_New         : return(MTEntryPanel_New         (cl, obj, (APTR)msg));
  1285.         case MUIM_MTEntryPanel_Edit        : return(MTEntryPanel_Edit        (cl, obj, (APTR)msg));
  1286.         case MUIM_MTEntryPanel_Remove      : return(MTEntryPanel_Remove      (cl, obj, (APTR)msg));
  1287.         case MUIM_MTEntryPanel_QuitEdit    : return(MTEntryPanel_QuitEdit    (cl, obj, (APTR)msg));
  1288.         case MUIM_MTEntryPanel_QuitEditAll : return(MTEntryPanel_QuitEditAll (cl, obj, (APTR)msg));
  1289.         case MUIM_MTEntryPanel_UpdateEntry : return(MTEntryPanel_UpdateEntry (cl, obj, (APTR)msg));
  1290.         case MUIM_MTEntryPanel_SetSave     : return(MTEntryPanel_SetSave     (cl, obj, (APTR)msg));
  1291.         case MUIM_MTEntryPanel_CheckConfig : return(MTEntryPanel_CheckConfig (cl, obj, (APTR)msg));
  1292.         case MUIM_MTEntryList_Load  :
  1293.         case MUIM_MTEntryList_Save  :
  1294.         {
  1295.             struct MTEntryPanel_Data *data = INST_DATA(cl, obj);
  1296.             return(DoMethodA((APTR)xget(data->Listview, MUIA_Listview_List), msg));
  1297.         }
  1298.     }
  1299.     return(DoSuperMethodA(cl, obj, msg));
  1300. }
  1301.  
  1302. /* mainwindow class */
  1303.  
  1304. #define MAINWINDOW_JUSTQUIT     0
  1305. #define MAINWINDOW_SAVEQUIT     1
  1306.  
  1307. struct MainWindow_Data
  1308. {
  1309.     Object  *MTEntryPanel;
  1310.     Object  *AboutmuiWin;
  1311.     BOOL    ChangeEnv;
  1312.     char    ConfigFile[MAXPATHNAMELENGTH], SaveAsFile[MAXPATHNAMELENGTH];
  1313. };
  1314.  
  1315.  
  1316. STRPTR getfilename(Object *win,char *title,char *initialname, BOOL save)
  1317. {
  1318.     static char buf[MAXPATHNAMELENGTH];
  1319.     char filename[MAXFILENAMELENGTH], pathname[MAXPATHNAMELENGTH];
  1320.     STRPTR temp;
  1321.     struct FileRequester *req;
  1322.     struct Window *w=(struct Window *) xget(win, MUIA_Window_Window);
  1323.     Object *app = (Object *)xget(win,MUIA_ApplicationObject);
  1324.     STRPTR res = NULL;
  1325.  
  1326.     strcpy(filename, FilePart(initialname));
  1327.     strcpy(pathname, initialname);
  1328.     temp=PathPart(pathname); *temp=0;
  1329.  
  1330.     if (req=MUI_AllocAslRequestTags(ASL_FileRequest,
  1331.         ASLFR_Window,           w,
  1332.         ASLFR_TitleText,        title,
  1333.         ASLFR_DoSaveMode,       save,
  1334.         ASLFR_InitialFile,      filename,
  1335.         ASLFR_InitialDrawer,    pathname,
  1336.         ASLFR_RejectIcons,      TRUE,
  1337.         TAG_DONE))
  1338.     {
  1339.         set(app,MUIA_Application_Sleep,TRUE);
  1340.         if (MUI_AslRequestTags(req,TAG_DONE))
  1341.         {
  1342.             if (*req->fr_File)
  1343.             {
  1344.                 res = buf;
  1345.                 CopyMem(req->fr_Drawer, buf, sizeof(buf));
  1346.                 AddPart(buf,req->fr_File,sizeof(buf));
  1347.             }
  1348.         }
  1349.         MUI_FreeAslRequest(req);
  1350.         set(app,MUIA_Application_Sleep,FALSE);
  1351.     }
  1352.     return(res);
  1353. }
  1354.  
  1355. void MainWindow_LoadConfig(struct IClass *cl, Object *obj)
  1356. {
  1357.     struct MainWindow_Data *data = INST_DATA(cl, obj);
  1358.     ULONG   i; char file[30];
  1359.  
  1360.     i = GetVar("METACONFIG", (STRPTR) &data->ConfigFile, MAXPATHNAMELENGTH, 0L);
  1361.  
  1362.     if(i>0) DoMethod((APTR)data->MTEntryPanel, MUIM_MTEntryList_Load, (STRPTR) data->ConfigFile, FALSE);
  1363.     else    strcpy(data->ConfigFile,"");
  1364.  
  1365.     strcpy(file,":MetaTool/MetaTool40.config");
  1366.     if (OSVersion>39)
  1367.         DoMethod((APTR)data->MTEntryPanel, MUIM_MTEntryList_Load, (STRPTR) file, TRUE);
  1368.  
  1369.     file[18] = '3'; i=9;
  1370.     for(; i>2; i--)
  1371.     {
  1372.         file[19] = '0' + i;
  1373.         DoMethod((APTR)data->MTEntryPanel, MUIM_MTEntryList_Load, (STRPTR) file, TRUE);
  1374.     }
  1375.  
  1376.     DoMethod((APTR)data->MTEntryPanel, MUIM_List_Sort);
  1377. }
  1378.  
  1379. ULONG MainWindow_SaveConfig(struct IClass *cl, Object *obj)
  1380. {
  1381.     struct MainWindow_Data *data = INST_DATA(cl, obj);
  1382.  
  1383.     if(strlen(data->ConfigFile)>0)
  1384.     {
  1385.  
  1386.         if(DoMethod((APTR)data->MTEntryPanel, MUIM_MTEntryList_Save, data->ConfigFile))
  1387.         {
  1388.             if(data->ChangeEnv)
  1389.             {
  1390.                 BPTR fh;
  1391.                 SetVar("METACONFIG", (STRPTR) data->ConfigFile,
  1392.                     strlen(data->ConfigFile), GVF_GLOBAL_ONLY);
  1393.                 if(fh=Open("ENVARC:METACONFIG", MODE_NEWFILE))
  1394.                 {
  1395.                     FPuts(fh, data->ConfigFile); Close(fh);
  1396.                     data->ChangeEnv=FALSE;
  1397.                 }
  1398.             }
  1399.             return(TRUE);
  1400.         }
  1401.     }
  1402.     return(FALSE);
  1403. }
  1404.  
  1405. ULONG MainWindow_About(struct IClass *cl, Object *obj, Msg msg)
  1406. {
  1407.     Object *app = (Object *) xget(obj, MUIA_ApplicationObject);
  1408.     MUI_Request(app, obj, 0, NULL, GetStr(MSG_OK), ABOUTTEXT,
  1409.         (char *)xget(app, MUIA_Application_Version)+20,
  1410.         (char *)xget(app, MUIA_Application_Copyright));
  1411.     return(0);
  1412. }
  1413.  
  1414. ULONG MainWindow_Aboutmui(struct IClass *cl, Object *obj, Msg msg)
  1415. {
  1416.     struct MainWindow_Data *data = INST_DATA(cl, obj);
  1417.  
  1418.     if (!data->AboutmuiWin)
  1419.     {
  1420.         data->AboutmuiWin = AboutmuiObject,
  1421.             MUIA_Window_RefWindow, obj,
  1422.             MUIA_Aboutmui_Application, xget(obj, MUIA_ApplicationObject),
  1423.         End;
  1424.     }
  1425.     if (data->AboutmuiWin) set(data->AboutmuiWin,MUIA_Window_Open,TRUE);
  1426.         else DisplayBeep(0);
  1427.     return(0);
  1428. }
  1429.  
  1430. ULONG MainWindow_Reload(struct IClass *cl, Object *obj, Msg msg)
  1431. {
  1432.     struct MainWindow_Data *data = INST_DATA(cl, obj);
  1433.  
  1434.     set((Object *)xget(obj, MUIA_ApplicationObject), MUIA_Application_Sleep, TRUE);
  1435.     DoMethod(data->MTEntryPanel, MUIM_MTEntryPanel_QuitEditAll);
  1436.     set(data->MTEntryPanel, MUIA_List_Quiet, TRUE);
  1437.     DoMethod(data->MTEntryPanel, MUIM_List_Clear);
  1438.     MainWindow_LoadConfig(cl, obj);
  1439.     set(data->MTEntryPanel, MUIA_List_Quiet, FALSE);
  1440.     set((Object *)xget(obj, MUIA_ApplicationObject), MUIA_Application_Sleep, FALSE);
  1441.     return(0);
  1442. }
  1443.  
  1444. ULONG MainWindow_Save(struct IClass *cl, Object *obj, Msg msg)
  1445. {
  1446.     set((Object *)xget(obj, MUIA_ApplicationObject), MUIA_Application_Sleep, TRUE);
  1447.     MainWindow_SaveConfig(cl, obj);
  1448.     set((Object *)xget(obj, MUIA_ApplicationObject), MUIA_Application_Sleep, FALSE);
  1449.  
  1450.     return(0);
  1451. }
  1452.  
  1453. ULONG MainWindow_SaveAs(struct IClass *cl, Object *obj, Msg msg)
  1454. {
  1455.     struct MainWindow_Data *data = INST_DATA(cl, obj);
  1456.     STRPTR file;
  1457.  
  1458.     if((file=getfilename(obj, GetStr(MSG_MAINWINDOW_PROJECT_SAVEAS),
  1459.         data->SaveAsFile, TRUE)) && *file)
  1460.     {
  1461.         set((Object *)xget(obj, MUIA_ApplicationObject), MUIA_Application_Sleep, TRUE);
  1462.         strcpy(data->SaveAsFile, file);
  1463.         DoMethod((APTR)data->MTEntryPanel, MUIM_MTEntryList_Save, data->SaveAsFile);
  1464.         set((Object *)xget(obj, MUIA_ApplicationObject), MUIA_Application_Sleep, FALSE);
  1465.     }
  1466.     return(0);
  1467. }
  1468.  
  1469. ULONG MainWindow_ChangeConfigFile(struct IClass *cl, Object *obj, Msg msg)
  1470. {
  1471.     struct MainWindow_Data *data = INST_DATA(cl, obj);
  1472.     STRPTR file;
  1473.  
  1474.     if((file=getfilename(obj, GetStr(MSG_MAINWINDOW_SETTINGS_CONFIGFILE),
  1475.         data->ConfigFile, FALSE)) && *file)
  1476.     {
  1477.         strcpy(data->ConfigFile, file); data->ChangeEnv = TRUE;
  1478.     }
  1479.     return(0);
  1480. }
  1481.  
  1482. ULONG MainWindow_MUISettings(struct IClass *cl, Object *obj, Msg msg)
  1483. {
  1484.     DoMethod((Object *) xget(obj, MUIA_ApplicationObject),
  1485.         MUIM_Application_OpenConfigWindow, 0);
  1486.     return(0);
  1487. }
  1488.  
  1489. ULONG MainWindow_Finish(struct IClass *cl, Object *obj,
  1490.                         struct MUIP_MainWindow_Finish *msg)
  1491. {
  1492.     struct MainWindow_Data *data = INST_DATA(cl, obj);
  1493.  
  1494.     if (xget(data->MTEntryPanel, MUIA_MTEntryPanel_CloseAble))
  1495.     {
  1496.         if (msg->quitmode==MAINWINDOW_SAVEQUIT)
  1497.             if(!MainWindow_SaveConfig(cl, obj))
  1498.                 return(0);
  1499.         DoMethod((Object *) xget(obj, MUIA_ApplicationObject), MUIM_Application_ReturnID,
  1500.             MUIV_Application_ReturnID_Quit);
  1501.     }
  1502.     else
  1503.     {
  1504.         MUI_Request((APTR)xget(obj, MUIA_ApplicationObject), obj,
  1505.         0, NULL, GetStr(MSG_OK), GetStr(MSG_MAINWINDOW_CANNOTQUIT_ERR));
  1506.     }
  1507.     return(0);
  1508. }
  1509.  
  1510. ULONG MainWindow_mNew(struct IClass *cl, Object *obj, struct opSet *msg)
  1511. {
  1512.     Object  *SaveBut, *CancelBut;
  1513.     Object  *Menustrip, *MTEntryPanel;
  1514.  
  1515.     obj = (Object *) DoSuperNew(cl,obj,
  1516.         MUIA_Window_Title,          GetStr(MSG_APP_TITLE),
  1517.         MUIA_Window_ScreenTitle,    GetStr(MSG_APP_TITLE),
  1518.         MUIA_Window_ID,             MAKE_ID('M','A','I','N'),
  1519.         MUIA_Window_Width,          MUIV_Window_Width_Visible(50),
  1520.         MUIA_Window_Height,         MUIV_Window_Height_Visible(50),
  1521.         MUIA_Window_Menustrip,      Menustrip =
  1522.                                         MUI_MakeObject(MUIO_MenustripNM, MainMenu, 0),
  1523.         WindowContents, VGroup,
  1524.             Child, MTEntryPanel = (Object *) NewObject(MTEntryPanel_Class->mcc_Class,
  1525.                        NULL, TAG_DONE),
  1526.             Child, MUI_MakeObject(MUIO_HBar, 2),
  1527.             Child, HGroup,
  1528.                 Child, SaveBut    = SimpleButton(GetStr(MSG_MAINWINDOW_SAVE_GAD)),
  1529.                 Child, CancelBut  = SimpleButton(GetStr(MSG_MAINWINDOW_CANCEL_GAD)),
  1530.             End,
  1531.         End,
  1532.         TAG_MORE, msg->ops_AttrList);
  1533.  
  1534.     if(obj)
  1535.     {
  1536.         struct MainWindow_Data *data = INST_DATA(cl, obj);
  1537.  
  1538.         data->MTEntryPanel = MTEntryPanel;
  1539.         data->AboutmuiWin  = NULL; data->ChangeEnv=FALSE;
  1540.         strcpy(data->SaveAsFile, "MetaTool.prefs");
  1541.  
  1542.         DoMethod(obj, MUIM_Notify, MUIA_Window_CloseRequest, TRUE,
  1543.                  obj, 2, MUIM_MainWindow_Finish, MAINWINDOW_JUSTQUIT);
  1544.         DoMethod(CancelBut, MUIM_Notify, MUIA_Pressed, FALSE,
  1545.                  obj, 2, MUIM_MainWindow_Finish, MAINWINDOW_JUSTQUIT);
  1546.         DoMethod(SaveBut, MUIM_Notify, MUIA_Pressed, FALSE,
  1547.                  obj, 2, MUIM_MainWindow_Finish, MAINWINDOW_SAVEQUIT);
  1548.         DoMethod((Object *) DoMethod(Menustrip, MUIM_FindUData, MEN_PROJECT_QUIT),
  1549.             MUIM_Notify, MUIA_Menuitem_Trigger, MUIV_EveryTime,
  1550.             obj, 1, MUIM_MainWindow_Finish, MAINWINDOW_JUSTQUIT);
  1551.  
  1552.         DoMethod((Object *) DoMethod(Menustrip, MUIM_FindUData, MEN_PROJECT_NEW),
  1553.             MUIM_Notify, MUIA_Menuitem_Trigger, MUIV_EveryTime,
  1554.             data->MTEntryPanel, 1, MUIM_List_Clear);
  1555.         DoMethod((Object *) DoMethod(Menustrip, MUIM_FindUData, MEN_PROJECT_RELOAD),
  1556.             MUIM_Notify, MUIA_Menuitem_Trigger, MUIV_EveryTime,
  1557.             obj, 1, MUIM_MainWindow_Reload);
  1558.         DoMethod((Object *) DoMethod(Menustrip, MUIM_FindUData, MEN_PROJECT_SAVE),
  1559.             MUIM_Notify, MUIA_Menuitem_Trigger, MUIV_EveryTime,
  1560.             obj, 1, MUIM_MainWindow_Save);
  1561.         DoMethod((Object *) DoMethod(Menustrip, MUIM_FindUData, MEN_PROJECT_SAVEAS),
  1562.             MUIM_Notify, MUIA_Menuitem_Trigger, MUIV_EveryTime,
  1563.             obj, 1, MUIM_MainWindow_SaveAs);
  1564.  
  1565.         DoMethod((Object *) DoMethod(Menustrip, MUIM_FindUData, MEN_SETTINGS_CONFIGNAME),
  1566.             MUIM_Notify, MUIA_Menuitem_Trigger, MUIV_EveryTime,
  1567.             obj, 1, MUIM_MainWindow_ChangeConfigFile);
  1568.         DoMethod((Object *) DoMethod(Menustrip, MUIM_FindUData, MEN_SETTINGS_MUI),
  1569.             MUIM_Notify, MUIA_Menuitem_Trigger, MUIV_EveryTime,
  1570.             obj, 1, MUIM_MainWindow_MUISettings);
  1571.  
  1572.         DoMethod((Object *) DoMethod(Menustrip, MUIM_FindUData, MEN_ABOUT_APP),
  1573.             MUIM_Notify, MUIA_Menuitem_Trigger, MUIV_EveryTime,
  1574.             obj, 1, MUIM_MainWindow_About);
  1575.         DoMethod((Object *) DoMethod(Menustrip, MUIM_FindUData, MEN_ABOUT_MUI),
  1576.             MUIM_Notify, MUIA_Menuitem_Trigger, MUIV_EveryTime,
  1577.             obj, 1, MUIM_MainWindow_Aboutmui);
  1578.  
  1579.         set(SaveBut,   MUIA_ShortHelp, (ULONG) GetStr(MSG_MAINWINDOW_SAVE_GAD_HELP));
  1580.         set(CancelBut, MUIA_ShortHelp, (ULONG) GetStr(MSG_MAINWINDOW_CANCEL_GAD_HELP));
  1581.  
  1582.         MainWindow_LoadConfig(cl, obj);
  1583.     }
  1584.     return((ULONG)obj);
  1585. }
  1586.  
  1587. ULONG __saveds MainWindow_Dispatcher(register __a0 struct IClass *cl,
  1588.                                      register __a2 Object        *obj,
  1589.                                      register __a1 Msg           msg)
  1590. {
  1591.     switch (msg->MethodID)
  1592.     {
  1593.         case OM_NEW                     : return(MainWindow_mNew     (cl, obj, (APTR)msg));
  1594.         case MUIM_MainWindow_About      : return(MainWindow_About    (cl, obj, (APTR)msg));
  1595.         case MUIM_MainWindow_Aboutmui   : return(MainWindow_Aboutmui (cl, obj, (APTR)msg));
  1596.         case MUIM_MainWindow_Reload     : return(MainWindow_Reload   (cl, obj, (APTR)msg));
  1597.         case MUIM_MainWindow_Save       : return(MainWindow_Save     (cl, obj, (APTR)msg));
  1598.         case MUIM_MainWindow_SaveAs     : return(MainWindow_SaveAs   (cl, obj, (APTR)msg));
  1599.         case MUIM_MainWindow_ChangeConfigFile :
  1600.             return(MainWindow_ChangeConfigFile (cl, obj, (APTR)msg));
  1601.         case MUIM_MainWindow_MUISettings :
  1602.             return(MainWindow_MUISettings      (cl, obj, (APTR)msg));
  1603.         case MUIM_MainWindow_Finish : return(MainWindow_Finish (cl, obj, (APTR)msg));
  1604.     }
  1605.     return(DoSuperMethodA(cl, obj, msg));
  1606. }
  1607.  
  1608. /* app class */
  1609.  
  1610. ULONG App_mNew(struct IClass *cl, Object *obj, struct opSet *msg)
  1611. {
  1612.     Object  *mainwindow;
  1613.  
  1614.     obj = (Object *)DoSuperNew(cl, obj,
  1615.         MUIA_Application_Title,         GetStr(MSG_APP_TITLE),
  1616.         MUIA_Application_Version,       APP_VERSION,
  1617.         MUIA_Application_Copyright,     APP_COPYRIGHT,
  1618.         MUIA_Application_Author,        APP_AUTHOR,
  1619.         MUIA_Application_Description,   GetStr(MSG_APP_DESCRIPTION),
  1620.         MUIA_Application_Base,          APP_BASE,
  1621.         MUIA_Application_Window,        mainwindow = NewObject(MainWindow_Class->mcc_Class,
  1622.                                             NULL, TAG_DONE),
  1623.         TAG_MORE, msg->ops_AttrList);
  1624.  
  1625.     if(obj)
  1626.     {
  1627.         set(mainwindow, MUIA_Window_Open, TRUE);
  1628.     }
  1629.     return((ULONG)obj);
  1630. }
  1631.  
  1632. ULONG __saveds App_Dispatcher(register __a0 struct IClass *cl,
  1633.                               register __a2 Object        *obj,
  1634.                               register __a1 Msg           msg)
  1635. {
  1636.     switch (msg->MethodID)
  1637.     {
  1638.         case OM_NEW                 : return(App_mNew   (cl, obj, (APTR)msg));
  1639.     }
  1640.     return(DoSuperMethodA(cl, obj, msg));
  1641. }
  1642.  
  1643. /* headquarter ;-) */
  1644.  
  1645.  
  1646. int main();
  1647.  
  1648. int wbmain(struct WBStartup *wb)
  1649. {
  1650.     LONG rc;
  1651.     WBenchMsg=wb;
  1652.     rc=main();
  1653.     return(rc);
  1654. }
  1655.  
  1656. int main()
  1657. {
  1658.     BPTR olddir=NULL; ULONG i; struct Library *lib;
  1659.  
  1660.     if (WBenchMsg)
  1661.         if (WBenchMsg->sm_ArgList->wa_Lock)
  1662.             olddir = CurrentDir(WBenchMsg->sm_ArgList->wa_Lock);
  1663.  
  1664.     if(!(MUIMasterBase=(struct Library *) OpenLibrary(MUIMASTER_NAME,MUIMASTER_VMIN)))
  1665.         goto exit;
  1666.  
  1667.     i=40; while(!(lib = OpenLibrary("intuition.library", i))) i--;
  1668.     CloseLibrary(lib); OSVersion=i;
  1669.  
  1670.  
  1671.     if(LocaleBase)
  1672.     {
  1673.         Catalog = OpenCatalog(NULL, "MetaToolPrefs.catalog",
  1674.             OC_Version, MTPREFS_CATALOGVERSION, TAG_DONE);
  1675.         LocalizeNewMenu(MainMenu); LocalizeNewMenu(MTEntryPanelMenu);
  1676.     }
  1677.  
  1678.     DragString_Class  = MUI_CreateCustomClass(NULL, MUIC_String, NULL,
  1679.         sizeof(struct DragString_Data), DragString_Dispatcher);
  1680.     if(!DragString_Class) goto exit;
  1681.  
  1682.     MTEntryList_Class   = MUI_CreateCustomClass(NULL, MUIC_List, NULL,
  1683.         sizeof(struct MTEntryList_Data), MTEntryList_Dispatcher);
  1684.     if(!MTEntryList_Class) goto exit;
  1685.  
  1686.     MTEditWindow_Class  = MUI_CreateCustomClass(NULL, MUIC_Window, NULL,
  1687.         sizeof(struct MTEditWindow_Data), MTEditWindow_Dispatcher);
  1688.     if(!MTEditWindow_Class) goto exit;
  1689.  
  1690.     MTEntryPanel_Class  = MUI_CreateCustomClass(NULL, MUIC_Group, NULL,
  1691.         sizeof(struct MTEntryPanel_Data), MTEntryPanel_Dispatcher);
  1692.     if(!MTEntryPanel_Class) goto exit;
  1693.  
  1694.     MainWindow_Class = MUI_CreateCustomClass(NULL, MUIC_Window, NULL,
  1695.         sizeof(struct MainWindow_Data), MainWindow_Dispatcher);
  1696.     if(!MainWindow_Class) goto exit;
  1697.  
  1698.     App_Class = MUI_CreateCustomClass(NULL, MUIC_Application, NULL,
  1699.         0L, App_Dispatcher);
  1700.     if(!App_Class) goto exit;
  1701.  
  1702.     App = NewObject(App_Class->mcc_Class, NULL, TAG_DONE);
  1703.  
  1704.     if (!App) goto exit;
  1705.  
  1706.     {
  1707.         ULONG signals=0;
  1708.         while (DoMethod(App, MUIM_Application_Input,&signals)!=
  1709.             MUIV_Application_ReturnID_Quit)
  1710.         {
  1711.             if (signals) Wait(signals);
  1712.         }
  1713.     }
  1714.  
  1715. exit:
  1716.     if (App)                MUI_DisposeObject(App);
  1717.     if (App_Class)          MUI_DeleteCustomClass(App_Class);
  1718.     if (MainWindow_Class)   MUI_DeleteCustomClass(MainWindow_Class);
  1719.     if (MTEntryPanel_Class) MUI_DeleteCustomClass(MTEntryPanel_Class);
  1720.     if (MTEditWindow_Class) MUI_DeleteCustomClass(MTEditWindow_Class);
  1721.     if (MTEntryList_Class)  MUI_DeleteCustomClass(MTEntryList_Class);
  1722.     if (DragString_Class)   MUI_DeleteCustomClass(DragString_Class);
  1723.     if (Catalog)            CloseCatalog(Catalog);
  1724.     if (DOSPathBase)        CloseLibrary(DOSPathBase);
  1725.     if (MUIMasterBase)      CloseLibrary(MUIMasterBase);
  1726.     if (olddir)             CurrentDir(olddir);
  1727. }
  1728.  
  1729.